# -*- coding: utf-8 -*-

'''
Created on 13 de Abr de 2011

@author: JvBatista
'''

# processamento de HTML através do parser BeautifulSoup
from BeautifulSoup import BeautifulSoup
import re

# biblioteca para acesso através de protocolos de Internet
import urllib2

class getData(object):
    '''
    classdocs
    '''
    
    # url base do sistema Rebides
    URL_REBIDES = 'http://www.rebides.oces.mctes.pt/Rebides'
    
    def break_into_site(self, url):
        
        try:
            # abre a conexao para o site
            file = urllib2.urlopen( url )
        except:
            print "Connection Error", url
            pass


        try:
            # leitura dos dados da pagina
            data = file.read()
        except:
            print "Read Error"
            pass
        else:
            file.close()

        # processamento dos dados da página
        soup = BeautifulSoup(data)
        
        return soup
        
    def return_list(self):
        
        list = soup.findAll('a', )
        
        return list

    def get_estabelishment_type_code(self, year):
        '''
        a funcao obtem os codigos dos tipos de estabelecimento
        de ensino superior
    
        ano - ano a que se referem os dados
        '''

        # formacao do Universal Resource Locator
        # a partir do ano
        url = getData().URL_REBIDES + '0' + str(year)

        soup = self.break_into_site(url)

        # os codigos vao estar associados ao
        # tipo de estabelecimento
        estabelishment_type_d = {}
        
        for x in list:
            # href vai ter o conteudo da referencia em HTML
            href = x['href']

            # remove de href tudo menos o codigo
            href = re.sub('rebid\_m1\.asp\?codr\=', '', href)
        
            # o conteudo encontra-se do tag encontra-se aqui
            contents = x.contents
        
            # converte para utf-8
            estabelishment_type = contents[0].encode('utf-8')
            estabelishment_type_d[ estabelishment_type ] = href
            pass
        return estabelishment_type_d

    def print_estabelishment_type_codes(self):
    
        establishment_type = self.get_estabelishment_type_code(0)
        for key, value in establishment_type.iteritems():
            print key, ':', value


    def get_estabelishment_code(self, year, estabelishment_code_type):
    
        '''
        a funcao obtem os codigos dos tipos de estabelishment
        de ensino superior
    
        year - ano a que se referem os data
        '''

        # formacao do Universal Resource Locator
        # a partir do ano
        url = self.URL_REBIDES + '0' + str(year)
        url = url + '/rebid_m1.asp?codr=' + estabelishment_code_type

        soup = self.break_into_site(url)

        # os codigos vao estar associados ao
        # tipo de estabelishment
        estabelishment_d = {}

        list = soup.findAll('a', )
        for x in list:
            # href vai ter o conteudo da referencia em HTML
            href = x['href']

            # remove de href tudo menos o codigo
            search_key = \
                'rebid\_m2\.asp\?CodR\={0}\&CodP\='.\
                format(estabelishment_code_type)

            href = re.sub(search_key, '', href)

            # o conteudo encontra-se do tag encontra-se aqui
            contents = x.contents
        
            # converte para utf-8
            estabelishment = contents[0].encode('utf-8')

            estabelishment_d[ estabelishment ] = href
            pass

        return estabelishment_d

    def print_estabelishment_codes(self):
    
        # exemplo de pesquisa de codigos de estabelecimentos        
        for ano in range(0,10):
            d_tipos_estabelecimento = self.get_estabelishment_type_code(ano)
            for tipo_estabelecimento, codigo_tipo_estabelecimento in d_tipos_estabelecimento.iteritems():
                d_estabelecimentos = self.get_estabelishment_code(ano, codigo_tipo_estabelecimento)
                for name, code in d_estabelecimentos.iteritems():
                    print ano , name , code
            pass
        pass


    def obter_informacao_docentes(self, ano, tipo, codR, estabelecimento, codP):
        '''
        codR - codigo do tipo de estabelecimento
        codP - codigo do estabelecimento
        '''
        C_NOME_COMPLETO = 1
        C_GRAU = 3
        C_CURSO = 5
        C_CATEGORIA = 7
        C_REGIME = 9

        # formacao do Universal Resource Locator
        # a partir do ano
        url = self.URL_REBIDES + '0' + str(ano)
        url = url + '/rebid_m2.asp?CodR=' + codR + '&CodP=' + codP 
        
        soup = self.break_into_site(url)
    
        lista = soup.findAll('tr', )
    
        lista_docentes = []

        for x in lista:
            nome = x.contents[C_NOME_COMPLETO].contents[0]
        
            grau = x.contents[C_GRAU].contents[0]
            grau = grau.lstrip()
        
            curso = x.contents[C_CURSO].contents[0]
            curso = curso.lstrip()

            categoria = x.contents[C_CATEGORIA].contents[0]

            regime = x.contents[C_REGIME].contents[0]

            conteudo = x.contents[11].findAll('a')
            for y in conteudo:
                # href vai ter o conteudo da referencia em HTML
                href = y['href']

                chave_procura = 'rebid\_m3\.asp\?CodD\='
                href = re.sub(chave_procura, '', href)

                chave_procura = '\&CodP\={0}'.format(codP)
                codigo_docente = re.sub(chave_procura, '', href)
                pass

            if nome != "NOME COMPLETO":
                if nome.encode('utf-8') != '&nbsp;':
                    nome_completo = nome
                    nome_completo = nome_completo.expandtabs()
                    novo_completo = re.sub('\015', '', nome_completo)
                    nome_completo = novo_completo.lstrip()
                    nome_completo = nome_completo.encode('utf-8')
                
                    categoria_completo = categoria.lstrip()
                    categoria_completo = categoria_completo.encode('utf-8')

                    regime_completo = regime.lstrip()
                    regime_completo = regime_completo.encode('utf-8')
                
                    codigo_docente_completo = codigo_docente
                    pass

                grau_completo = grau.encode('utf-8')
                curso_completo = curso.encode('utf-8')

                informacao_docente = [ codigo_docente_completo,
                                      nome_completo,
                                      grau_completo,
                                      curso_completo,
                                      categoria_completo,
                                      regime_completo,
                                      ano,
                                      tipo,
                                      estabelecimento]
                lista_docentes.append(informacao_docente)
                pass
            pass
        return lista_docentes

#getData().print_estabelishment_type_codes()
#getData().print_estabelishment_codes()